home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / misc / gs261src.zip / zbseq.c < prev    next >
C/C++ Source or Header  |  1993-05-13  |  8KB  |  293 lines
  1. /* Copyright (C) 1990, 1992, 1993 Aladdin Enterprises.  All rights reserved.
  2.  
  3. This file is part of Ghostscript.
  4.  
  5. Ghostscript is distributed in the hope that it will be useful, but
  6. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  7. to anyone for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.  Refer
  9. to the Ghostscript General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute
  12. Ghostscript, but only under the conditions described in the Ghostscript
  13. General Public License.  A copy of this license is supposed to have been
  14. given to you along with Ghostscript so you can know your rights and
  15. responsibilities.  It should be in a file named COPYING.  Among other
  16. things, the copyright notice and this notice must be preserved on all
  17. copies.  */
  18.  
  19. /* zbseq.c */
  20. /* Level 2 binary object sequence operators */
  21. #include "ghost.h"
  22. #include "errors.h"
  23. #include "oper.h"
  24. #include "save.h"
  25. #include "store.h"
  26. #include "stream.h"
  27. #include "files.h"
  28. #include "iname.h"
  29. #include "bnum.h"
  30. #include "btoken.h"
  31. #include "bseq.h"
  32.  
  33. /* Current binary format (in iscan.c) */
  34. extern ref ref_binary_object_format;
  35.  
  36. /* System and user name arrays. */
  37. ref system_names, user_names;
  38.  
  39. /* Import the Level 2 scanner extensions. */
  40. extern int scan_binary_token(P3(stream *, ref *, int));
  41. extern int (*scan_btoken_proc)(P3(stream *, ref *, int));
  42. extern void scan_ascii85_setup(P4(stream *, stream *, byte *, uint));
  43. extern void (*scan_ascii85_setup_proc)(P4(stream *, stream *, byte *, uint));
  44.  
  45. /* Initialize the Level 2 scanning machinery. */
  46. private void
  47. zbseq_init(void)
  48. {    /* Initialize fake system and user name tables. */
  49.     /* PostScript code will install the real ones. */
  50.     make_tasv(&system_names, t_shortarray, a_readonly, 0, packed, NULL);
  51.     make_tasv(&user_names, t_array, a_all, 0, refs, NULL);
  52.     scan_btoken_proc = scan_binary_token;
  53.     scan_ascii85_setup_proc = scan_ascii85_setup;
  54. }
  55.  
  56. /* <system_names> <user_names> .installnames - */
  57. int
  58. zinstallnames(register os_ptr op)
  59. {    check_read_type(op[-1], t_shortarray);
  60.     check_type(*op, t_array);
  61.     ref_assign_old(&system_names, op - 1, ".installnames");
  62.     ref_assign_old(&user_names, op, ".installnames");
  63.     pop(2);
  64.     return 0;
  65. }
  66.  
  67. /* - currentobjectformat <int> */
  68. int
  69. zcurrentobjectformat(register os_ptr op)
  70. {    push(1);
  71.     *op = ref_binary_object_format;
  72.     return 0;
  73. }
  74.  
  75. /* <int> setobjectformat - */
  76. int
  77. zsetobjectformat(register os_ptr op)
  78. {    check_type(*op, t_integer);
  79.     if ( op->value.intval < 0 || op->value.intval > 4 )
  80.         return_error(e_rangecheck);
  81.     ref_assign_old(&ref_binary_object_format, op, "setobjectformat");
  82.     pop(1);
  83.     return 0;
  84. }
  85.  
  86. /* <file> <tag> <array> .writeobjects - */
  87. /* Internal definitions */
  88. typedef struct { ulong refs, chars; } bin_space;
  89. private int bin_seq_push(P2(os_ptr, bin_space *));
  90. private void bin_seq_write_objects(P6(stream *, const_os_ptr, const_os_ptr,
  91.   byte, ulong, ulong));
  92. private void bin_seq_write_strings(P3(stream *, const_os_ptr, const_os_ptr));
  93. int
  94. zwriteobjects(register os_ptr op)
  95. {    stream *s;
  96.     int code;
  97.     int bin_format = (int)ref_binary_object_format.value.intval - 1;
  98.     bin_space space;
  99.     ulong total;
  100.     byte tag;
  101.     os_ptr op1 = op - 1;
  102.     os_ptr top;
  103.     ulong apos;
  104.     static const int nfs[4] =
  105.        {    num_float_IEEE + num_msb,
  106.         num_float_IEEE + num_lsb,
  107.         num_float_native + num_msb,
  108.         num_float_native + num_lsb
  109.        };
  110.     if ( bin_format < 0 )
  111.         return_error(e_undefined);
  112.     check_write_file(s, op - 2);
  113.     check_type(*op1, t_integer);
  114.     if ( op1->value.intval < 0 || op1->value.intval > 255 )
  115.         return_error(e_rangecheck);
  116.     tag = (byte)op1->value.intval;
  117.     check_read_type(*op, t_array);
  118.     space.refs = space.chars = 0;
  119.     code = bin_seq_push(op, &space);
  120.     if ( code < 0 ) return code;
  121.     top = op + code;
  122.     /* Object has been validated, only possible error now is */
  123.     /* ioerror (which we don't check for). */
  124.     total = space.refs * sizeof(bin_seq_obj) + space.chars;
  125.     apos = r_size(op) * (ulong)sizeof(bin_seq_obj);
  126.     s->num_format = nfs[bin_format];
  127.     sputc(s, (byte)bt_seq + bin_format);
  128.     if ( total > 0xffff - 4 )        /* use long format */
  129.     {    sputc(s, 0);
  130.         sputshort(s, r_size(op));
  131.         sputlong(s, total + 8);
  132.     }
  133.     else                    /* use short format */
  134.     {    sputc(s, (byte)r_size(op));
  135.         sputshort(s, (ushort)total + 4);
  136.     }
  137.     bin_seq_write_objects(s, op, top, tag, apos, total - space.chars);
  138.     bin_seq_write_strings(s, op, top);
  139.     pop(3);
  140.     return 0;
  141. }
  142.  
  143. /* ------ Initialization procedure ------ */
  144.  
  145. op_def zbseq_op_defs[] = {
  146.     {"2.installnames", zinstallnames},
  147.     {"0currentobjectformat", zcurrentobjectformat},
  148.     {"1setobjectformat", zsetobjectformat},
  149.     {"3.writeobjects", zwriteobjects},
  150.     op_def_end(zbseq_init)
  151. };
  152.  
  153. /* ------ Internal routines ------ */
  154.  
  155. /* Recursively scan arrays breadth-first and push onto the stack. */
  156. /* Compute the space requirements at the same time. */
  157. /* Return the number of arrays on the stack, but don't change osp. */
  158. private int
  159. bin_seq_push(os_ptr op0, bin_space *bsp)
  160. {    register os_ptr op = op0;
  161.     os_ptr top = op;
  162.     while ( op <= top )
  163.     {    uint i = r_size(op);
  164.         const ref *ep = op->value.const_refs;
  165.         bsp->refs += i;
  166.         for ( ; i; i--, ep++ )
  167.           switch ( r_type(ep) )
  168.         {
  169.         case t_null: case t_integer: case t_real:
  170.         case t_boolean: case t_mark:
  171.             break;
  172.         case t_string:
  173.             check_read(*ep);
  174.             bsp->chars += r_size(ep);
  175.             break;
  176.         case t_name:
  177.         {    ref nstr;
  178.             name_string_ref(ep, &nstr);
  179.             bsp->chars += r_size(&nstr);
  180.         }    break;
  181.         case t_array:
  182.         {    check_read(*ep);
  183.             if ( top == ostop )
  184.                 return_error(e_limitcheck);
  185.             top++;
  186.             ref_assign(top, ep);
  187.         }    break;
  188.         default:
  189.             return_error(e_typecheck);
  190.         }
  191.         op++;
  192.     }
  193.     return top - op0;
  194. }
  195.  
  196. /* Write the objects part of a binary object sequence. */
  197. private void
  198. bin_seq_write_objects(stream *s, const_os_ptr op, const_os_ptr top,
  199.   byte tag, ulong apos, ulong spos)
  200. {    bin_seq_obj ob;
  201.     ref nstr;
  202.     ob.unused = tag;
  203. #define swap_t(a, b) t = a, a = b, b = t
  204. #if arch_is_big_endian
  205. #  define must_swap(s) s_is_lsb(s)
  206. #else
  207. #  define must_swap(s) s_is_msb(s)
  208. #endif
  209.     for ( ; op <= top; op++ )
  210.     {    uint i = r_size(op);
  211.         const ref *ep = op->value.const_refs;
  212.         for ( ; i; i--, ep++ )
  213.         {    switch ( r_type(ep) )
  214.             {
  215.             case t_null:
  216.                 ob.tx = (byte)bs_null;
  217.                 break;
  218.             case t_mark:
  219.                 ob.tx = (byte)bs_mark;
  220.                 break;
  221.             case t_integer:
  222.                 ob.tx = (byte)bs_integer;
  223.                 ob.value.w = ep->value.intval;
  224. num:                ob.size.w = 0;    /* (matters for reals) */
  225. swb:                /* swap bytes of value if needed */
  226.                 if ( must_swap(s) )
  227.                 { byte t;
  228.                   swap_t(ob.value.b[0], ob.value.b[3]);
  229.                   swap_t(ob.value.b[1], ob.value.b[2]);
  230.                 }
  231.                 break;
  232.             case t_real:
  233.                 ob.tx = (byte)bs_real;
  234.                 ob.value.f = ep->value.realval;
  235.                 /***** handle non-IEEE native *****/
  236.                 goto num;
  237.             case t_boolean:
  238.                 ob.tx = (byte)bs_boolean;
  239.                 ob.value.w = ep->value.index;
  240.                 goto num;
  241.             case t_array:
  242.                 ob.tx = (byte)bs_array;
  243.                 if ( r_has_attr(ep, a_executable) )
  244.                     ob.tx += (byte)bs_executable;
  245.                 ob.size.w = r_size(ep);
  246.                 ob.value.w = apos;
  247.                 apos += ob.size.w * (ulong)sizeof(bin_seq_obj);
  248.                 goto nsa;
  249.             case t_string:
  250.                 ob.tx = (byte)bs_string;
  251.                 if ( r_has_attr(ep, a_executable) )
  252.                     ob.tx += (byte)bs_executable;
  253.                 ob.size.w = r_size(ep);
  254. nos:                ob.value.w = spos;
  255.                 spos += ob.size.w;
  256. nsa:                if ( must_swap(s) )
  257.                 { byte t;
  258.                   swap_t(ob.size.b[0], ob.size.b[1]);
  259.                 }
  260.                 goto swb;
  261.             case t_name:
  262.                 ob.tx = (byte)bs_name;
  263.                 name_string_ref(ep, &nstr);
  264.                 ob.size.w = r_size(&nstr);
  265.                 goto nos;
  266.             }
  267.             sputs(s, (byte *)&ob, sizeof(bin_seq_obj));
  268.             ob.unused = 0;        /* tag first object only */
  269.         }
  270.     }
  271. }
  272.  
  273. /* Write the string part of a binary object sequence */
  274. private void
  275. bin_seq_write_strings(stream *s, const_os_ptr op, const_os_ptr top)
  276. {    for ( ; op <= top; op++ )
  277.     {    uint i = r_size(op);
  278.         const ref *ep = op->value.const_refs;
  279.         for ( ; i; i--, ep++ )
  280.           switch ( r_type(ep) )
  281.         {
  282.         case t_name:
  283.         {    ref nstr;
  284.             name_string_ref(ep, &nstr);
  285.             sputs(s, nstr.value.bytes, r_size(&nstr));
  286.         }    break;
  287.         case t_string:
  288.             sputs(s, ep->value.bytes, r_size(ep));
  289.             break;
  290.         }
  291.     }
  292. }
  293.